import { mergeCart, findCartList, insertCart, deleteCart, updateCart, checkAllCart } from '@/api/cart'
// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: [] // 商品列表
    }
  },
  getters: {
    // 有效的商品列表 isEddective要为true并且数量要小于库存
    effectiveList (state) {
      // 过滤
      return state.list.filter(it => it.isEffective && it.count <= it.stock)
    },
    // 2.总价格
    // 在上一个计算熟悉的基础上，计算
    // 如何从一个getters中访问另一个getters
    allAmount (state, getters) {
      return getters.effectiveList.reduce((acc, cur) => acc + cur.count * cur.nowPrice, 0)
    },
    // 3.总件数
    allCount (state, getters) {
      return getters.effectiveList.reduce((acc, cur) => acc + cur.count, 0)
    },
    // 4.无效商品
    invalidList (state) {
      return state.list.filter(it => it.stock === 0 || it.isEffective === false)
    },
    // 5.已选商品
    selectedList (state, getters) {
      return getters.effectiveList.filter(it => it.selected)
    },
    // 6.已选商品总件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((acc, cur) => acc + cur.count, 0)
    },
    // 已选商品总金额
    selectedAmount (state, getters) {
      return getters.selectedList.reduce((acc, cur) => acc + cur.count * cur.nowPrice, 0)
    },
    // 是否全选
    isCheckAll (state, getters) {
      return (getters.selectedList.length === getters.effectiveList.length) && (getters.effectiveList.length > 0)
    }
  },
  mutations: {
    insertCart (state, goods) {
      // 如果这个商品已经存在就数量增加
      const good = state.list.find(item => item.skuId === goods.skuId)
      if (good) {
        good.count += goods.count
      } else {
        state.list.push(goods)
      }
    },
    // 删除
    deleteCart (state, skuId) {
      // 删除商品
      // 1. 找下标
      const idx = state.list.findIndex(it => it.skuId === skuId)
      if (idx > -1) {
        // 2. 删除
        state.list.splice(idx, 1)
      }
    },
    // 修改购物车中的商品
    // goods中字段有可能不完整，goods有的信息才能去修改
    // 修改购物车商品
    // goods中字段有可能不完整，goods有的信息才去修改。
    updateCart (state, goods) {
      // 1. goods中必需有skuId，才能找到对应的商品信息
      // 2. 找到
      console.log(goods)
      console.log(state.list)
      const updateGoods = state.list.find(item => item.skuId === goods.skuId)
      console.log(updateGoods)
      for (const key in goods) {
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          updateGoods[key] = goods[key]
        }
      }
    },
    // 修改sku
    updateCartSku (state, { newSku: oldSkuId, oldSkuId: newSku }) {
      // 1. 找到老的SKU
      // 2. 用新的SKU信息 结合老的SKU等到一份 全新的数据
      // 3. 删除老的SKU
      // 4. 把 全新的数据 添加进去
      console.log(newSku)
      const oldSkuIdx = state.list.findIndex(it => it.skuId === oldSkuId)
      console.log(oldSkuIdx)
      if (oldSkuIdx === -1) {
        return
      }
      console.log(oldSkuIdx)
      const oldSkuCopy = { ...state.list[oldSkuIdx] }
      console.log('老的sku', oldSkuCopy)
      // 解构赋值重命名
      const { oldPrice: price, price: nowPrice, skuId, specsText: attrsText, inventory: stock } = newSku
      // 用新的SKU信息 结合老的SKU等到一份 全新的数据
      const newSkuNew = { ...oldSkuCopy, ...{ price, nowPrice, skuId, attrsText, stock } }

      // 3. 删除老的SKU
      // 4. 把 全新的数据 添加进去
      state.list.splice(oldSkuIdx, 1, newSkuNew)

      console.log('当前购物车', state.list)
      console.log('新的sku', newSkuNew)
    },
    // 设置购物车列表
    setCartList (state, list) {
      state.list = list
    }
  },

  actions: {
    insertCart (ctx, goods) {
      return new Promise((resolve, reject) => {
        // 在一个vuex的modiles中，如何获取另一个modules中的数据
        if (ctx.rootState.user.profile.token) {
          insertCart(goods).then(() => {
            return findCartList() // 获取新的购物车数据
          }).then((data) => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          console.log('actionsinsertCart', goods)

          // 调用mutations
          ctx.commit('insertCart', goods)
          resolve()
        }
      })
    },
    deleteCart (ctx, skuId) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // todo
          deleteCart([skuId]).then(() => {
            findCartList().then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
          })
        } else { // 没有登录
          // 调用mutations
          ctx.commit('deleteCart', skuId)
          resolve()
        }
      })
    },
    // 修改购物车商品（数量，是否选中）
    updateCart (ctx, goods) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          updateCart(goods).then(() => {
            findCartList().then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
          })
        } else {
          // 本地
          console.log(1)
          ctx.commit('updateCart', goods)
          resolve()
        }
      })
    },
    // 把所有的有效的商品统一设置selected的值
    checkAllCart (ctx, selected) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          const ids = ctx.getters.invalidList.map(item => item.skuId)
          checkAllCart({ selected, ids }).then(() => {
            findCartList().then(data => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
          })
        } else {
          // 没有登录
          // 对有效商品列表数据，循环调用mutations，更新选中的状态
          ctx.getters.effectiveList.forEach(it => {
            ctx.commit('updateCart', { skuId: it.skuId, selected: selected })
          })
          resolve()
        }
      })
    },
    // 批量删除选中的商品
    batchDeleteCart (ctx, isClear) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
        //  得到需要删除的商品列表(失效，选中)的skuid集合
          const ids = ctx.getters[isClear ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            return findCartList()
          }).then((data) => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 获取选中商品列表，进行遍历调用deleteCart mutataions函数
          ctx.getters[isClear ? 'invalidList' : 'selectedList'].forEach(item => {
            ctx.commit('deleteCart', item.skuId)
          })
          resolve()
        }
      })
    },
    // 修改sku规格函数
    updateCartSku (ctx, { newSku: oldSkuId, oldSkuId: newSku }) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录 TODO
          // 1. 获取原先商品的数量
          // 2. 删除原先商品
          // 3. 获取修改的skuId 和 原先商品数量 做一个加入购物车操作
          // 4. 更新列表
          const oldSku = ctx.state.list.find(it => it.skuId === oldSkuId)
          const count = oldSku.count // 获取数据
          // 1. 删除
          deleteCart([oldSkuId]).then(() => {
            // 2. 添加
            insertCart({ skuId: newSku.skuId, count }).then(() => {
              // 3. 获取最新的购物车
              findCartList().then(data => {
                ctx.commit('setCartList', data.result)
                resolve()
              })
            })
          })
        } else {
          console.log(111111111111111)
          ctx.commit('updateCartSku', { newSku, oldSkuId })
          resolve()
        }
      })
    },
    // 登录成功之后
    // 1.把本地购物车上传到服务器--他会合并
    // 获取服务器最新的购物车数据同步到vuex
    async mergeLocalCart (ctx) {
      const list = ctx.state.list.map(it => {
        return {
          skuId: it.skuId,
          count: it.count,
          selected: it.selected
        }
      })
      await mergeCart(list)
      // 获取服务器最新的购物车数据，同步到vuex
      const data = await findCartList()
      ctx.commit('setCartList', data.result)
    }

  }
}
